Decisión Multicriterio

Transformación en los datos

from pandas import read_csv
import pandas as pd
import plotly.express as px
import flask

Aplicamos el algoritmo de decisión multicriterio a los modelos que, al menos, han obtenido un Win en la tabla Wins-Losses generada en el notebook Stastical_Analysis. Estos modelos son: GBR_Lag5, RF_Lag5, GBR_Lag3, Lasso_Lag5, SVR_Lag3 y EN_Lag5

#modelos = ['RF_lag3', 'RF_lag5', 'Lasso_lag5', 'SVR_lag3', 'GBR_lag3', 'GBR_lag5', 'EN_lag5']
modelos = ['RF_lag3', 'RF_lag5', 'Lasso_lag5', 'GBR_lag3', 'GBR_lag5', 'EN_lag5']

Leemos las tablas de errores que serán necesarios para la aplicación del algoritmo

RMSE_errores_test = read_csv('../Datos_preprocesados/RMSE_errores_test.csv', encoding ='latin-1', sep = ',', na_values = ['NaN', 'NaT'])
RMSE_errores_test.drop(columns = "Predicciones", inplace = True)
MAE_errores_test = read_csv('../Datos_preprocesados/MAE_errores_test.csv', encoding ='latin-1', sep = ',', na_values = ['NaN', 'NaT'])
MAE_errores_test.drop(columns = "Predicciones", inplace = True)
CC_test = read_csv('../Datos_preprocesados/CC_test.csv', encoding ='latin-1', sep = ',', na_values = ['NaN', 'NaT'])
CC_test.drop(columns = "Predicciones", inplace=True)

Descartamos de las tablas leídas aquellos modelos con los que no vamos a trabajar, creando para cada modelo al que aplicaremos el algoritmo una nueva tabla con RMSE, MAE y CC para cada una de las predicciones

# Guardaremos las tablas generadas para cada modelo en una lista
tablas = []

for i in range(0, len(modelos)):
    df = pd.DataFrame()
    df['RMSE'] = RMSE_errores_test[modelos[i]]
    df['MAE'] = MAE_errores_test[modelos[i]]
    # En el caso de CC, cuanto más alto mejor, al contrario que RMSE y MAE
    df['CC'] = round(1 - CC_test[modelos[i]],3)
    # Guardamos en un csv
    df.to_csv(path_or_buf = '../Datos_preprocesados/multicriterio_'+modelos[i]+'.csv')
    # Añadimos a la lista
    tablas.append(df)

Visualización de los errores

i = 0
for t in tablas:
    
    # Creamos df 
    datos = {'RMSE': t['RMSE'].values,
             'MAE': t['MAE'].values,
             'CC': t['CC'].values}

    df = pd.DataFrame(data = datos)

    fig = px.line(df, x = t.index, y = df.columns,
                  title = 'RMSE, MAE, CC para el modelo '+modelos[i], width = 700, height = 400)
    
    #t[['RMSE','MAE','CC']].plot(grid = True,title = modelos[i])
    
    flask.Markup(fig)
    
    fig.show("notebook")
    
    i = i+1

Algoritmo de decisión multicriterio

El algoritmo trabaja con la normalización de los errores, así que vamos a normalizar las tablas

# Unimos todos los errores
union = pd.concat(tablas)
# Cogemos el minimo
minimo = union.min()
min_rmse = minimo[0]
min_mae = minimo[1]
min_cc = minimo[2]
# Cogemos el maximo
maximo = union.max()
max_rmse = maximo[0]
max_mae = maximo[1]
max_cc = maximo[2]

resultados = []

# Para cada modelo
for t in tablas:
    
    # Normalizamos el dataframe -> obtenemos los errores normalizados para el modelo
    t_norm = pd.DataFrame()
    t_norm['RMSE'] = (t['RMSE'] - min_rmse)/(max_rmse - min_rmse)
    t_norm['MAE'] = (t['MAE'] - min_mae)/(max_mae - min_mae)
    t_norm['CC'] = (t['CC'] - min_cc)/(max_cc - min_cc)

    # Ahora sumamos los errores -> obtenemos sRMSE, sMAE, sCC
    sRMSE = t_norm['RMSE'].sum()
    sMAE = t_norm['MAE'].sum()
    sCC = t_norm['CC'].sum()
    
    # Sumamos las diferencias absolutas error(i+1)-error(i)
    mas1_norm = t_norm.drop([0]).reset_index(drop = True)
    # Los valores obtenidos son mRMSE, mMAE, mCC
    diferencias_absolutas = abs(mas1_norm - t_norm).sum()
    
    # Sumamos el producto de los m y s
    #v_modelo = sRMSE*(diferencias_absolutas['RMSE']) + sMAE*(diferencias_absolutas['MAE']) + sCC*(diferencias_absolutas['CC'])

    # Sumamos los tres s -> SIN USAR PENDIENTES
    v_modelo = sRMSE + sMAE + sCC
    
    # Añadimos a la lista de resultados
    resultados.append(v_modelo)

for i in range(0,len(resultados)):
    print('Resultado modelo '+modelos[i]+' = '+str(resultados[i]))

Resultado modelo RF_lag3 = 15.683569641367804
Resultado modelo RF_lag5 = 14.283958854601057
Resultado modelo Lasso_lag5 = 11.621629135390602
Resultado modelo GBR_lag3 = 15.538726716708366
Resultado modelo GBR_lag5 = 12.710036141228802
Resultado modelo EN_lag5 = 10.316708368084516

mejor_resultado = min(resultados)
mejor_modelo = resultados.index(mejor_resultado)
print('Mejor modelo = '+str(modelos[mejor_modelo]+' -> Resultado = '+str(mejor_resultado)))

Mejor modelo = EN_lag5 -> Resultado = 10.316708368084516